Questions

25 of 38

1What is the Iterator Protocol in JavaScript? What two things must an object implement to be a valid iterator?

2What is the difference between an iterable and an iterator? Can something be both?

3What built-in JavaScript data structures are iterable by default? How does for...of work under the hood with them?

4What does Symbol.iterator do? How would you make a plain object iterable from scratch?

5What is a 'lazy' iterator and why is it important for performance? Give a practical example.

6How would you implement an infinite iterator (e.g., an infinite counter)? How do you safely consume it?

7What happens if you forget to return { done: true } in a custom iterator? What are the consequences?

8How would you implement a reusable iterable (one that can be iterated multiple times)?

9Can you chain or compose custom iterators? Implement a map and filter for a custom iterator without converting to an array.

10What is a generator function? How is it different from a regular function in terms of execution flow?

11Explain what yield does. What does calling .next() return before and after a yield?

12What is the difference between yield and return inside a generator?

13What does yield* do? How is it different from a regular yield?

14Can you pass a value into a generator using .next(value)? How does that work and what is the practical use case?

15Explain generator.return(value) and generator.throw(error). When would you use each in production?

16What happens to a try/finally block inside a generator when .return() is called externally?

17How do generators handle errors? How does .throw() interact with try/catch inside a generator?

18Are generators lazy? How do they differ from eager evaluation with arrays in terms of memory and performance?

19What is the difference between a regular iterator and an async iterator? What protocol does an async iterator follow?

20What does Symbol.asyncIterator do? How does for await...of use it?

21Implement an async generator that fetches paginated API data, yielding one page at a time:

22What are the pitfalls of using for await...of with an async generator that makes network calls? How do you handle errors and cancellation?

23How would you implement a readable stream as an async iterable in Node.js?

24How would you use a generator to implement redux-saga-style side effect management? What makes generators a good fit for this?

25How can generators be used to implement coroutines or cooperative multitasking in JavaScript?

26Implement a take(n) utility that takes the first n values from any iterable — including infinite ones:

27When would you choose a generator over returning an array? What are the memory trade-offs?

28In a data pipeline processing millions of records, how would you use generators to avoid loading everything into memory?

29What are the debugging challenges with generators (e.g., in stack traces and async flows)? How do you mitigate them?

30How do generators compose? Implement a pipeline of generator-based transformations (like RxJS operators but synchronous).

31What are the limitations of generators? What problems are they not a good fit for?

32What are Iterator Helpers (.map(), .filter(), .take(), .drop() on iterators natively)? What stage are they at in the TC39 proposal pipeline?

33How does Array.from() use the iterator protocol? What's the difference between passing an iterable vs an array-like object?

34How do Map, Set, Array, and String expose their iterators? Are they the same object or different?

35What is the difference between map.keys(), map.values(), and map.entries()? What do they return?

36How does destructuring and spread (...) use the iterator protocol internally?

37How would you implement Promise-based async/await using generators and a runner function? (This is essentially how Babel transpiled async/await early on.)

38How would you use a generator to implement a tree traversal (DFS) without recursion stack concerns?

25 / 38

How can generators be used to implement coroutines or cooperative multitasking in JavaScript?

Generators can yield control back to a scheduler, allowing multiple tasks to run interleaved (cooperative multitasking) without threads.

Coroutine scheduler

Difficulty: 6/10

Topics: generators, coroutines, cooperative multitasking

Scenario Questions

0-2 years experience

1
Write a generator that yields the numbers 1 through 5 and show how you would manually call next() to pause and resume it as a tiny cooperative task.
2
If you call next() on a generator that has already completed, what does JavaScript return, and how would you guard against that in a simple scheduler?
3
How could you use a generator to create a very small async/await polyfill for a function that returns a Promise?

2-5 years experience

1
We have a UI component that fetches data, renders it, then waits for a button click before continuing. How would you orchestrate that flow with a generator instead of callbacks or async/await?
2
During a code review you notice a generator‑based coroutine that sometimes hangs after an exception is thrown. What could cause the hang and how would you fix it?
3
What are the trade‑offs of using a generator‑driven task runner versus a promise‑based one in a Node.js microservice that processes a stream of events?

5-8 years experience

1
Design a cooperative multitasking scheduler for thousands of lightweight tasks in a browser game using generators. Which data structures and scheduling policy would you pick to keep the main thread responsive?
2
Our server uses a generator‑driven pipeline to handle incoming requests, and under load we see memory usage climb. Identify possible sources of memory leakage in generator usage and propose mitigations.
3
Compare the performance and debuggability of a generator‑based coroutine system versus async/await in a large codebase. When would you recommend each approach?

8+ years experience

1
We need to migrate a legacy codebase that relies on custom generator coroutines to a modern async/await architecture across several teams. How would you plan and execute that migration to minimize risk?
2
At the organization level, we are debating whether to standardize on generator‑based cooperative multitasking for all client‑side state machines. What architectural, tooling, and developer‑experience factors would influence that decision?
3
How would you design a cross‑team library that abstracts generator coroutines, providing a uniform API while allowing teams to plug in different scheduling strategies such as frame‑based, time‑slice, or priority queues?

Follow-up Questions

❓What happens if a generator throws an error and the scheduler doesn't catch it?
❓How would you expose this coroutine pattern to other developers on the team?
❓Can you compare this approach to using async/await in terms of stack traces?